isEnabled() is a Selenium WebDriver method used to check whether a web element is currently enabled and available for interaction according to WebDriver's enabled-state rules. It returns a boolean value: true when the element is enabled and false when the element is disabled.
It is commonly used with form controls such as buttons, text fields, checkboxes, radio buttons, select controls, and submit buttons. In Selenium automation, isEnabled() is useful for validating whether users can interact with a particular control at a specific point in a test.
JustAcademy's Selenium Automation Testing Course covers Selenium WebDriver, locators, WebElements, TestNG, data-driven testing, Page Object Model, cross-browser testing, automation frameworks, and real-time projects. These concepts provide the foundation for using WebElement methods such as isEnabled() in practical automation testing. Selenium Training Course
To explore the course through a practical demo session, visit Selenium Course Demo.
isEnabled() is a method of Selenium's WebElement interface. It checks whether the located element is enabled for interaction.
The method returns a boolean value:
For example, a Submit button may initially be disabled until the user enters all required information. Selenium can use isEnabled() to verify this state.
boolean status = element.isEnabled();Here, element represents a Selenium WebElement and status stores the enabled state returned by Selenium.
WebElement button = driver.findElement(By.id("submitBtn"));
boolean enabled = button.isEnabled();
System.out.println("Button enabled: " + enabled);
If the button is enabled, the output will be:
Button enabled: trueIf the button is disabled, the output will be:
Button enabled: falseModern web applications frequently enable or disable controls based on user actions, validation rules, permissions, application state, or data availability.
For example:
Using isEnabled(), automation scripts can verify these application states.
The return type of isEnabled() is boolean.
boolean result = element.isEnabled();| Return Value | Meaning |
|---|---|
| true | The element is enabled. |
| false | The element is disabled. |
One of the most common uses of isEnabled() is checking whether a button is enabled.
WebElement loginButton = driver.findElement(By.id("loginBtn"));
if(loginButton.isEnabled()){
System.out.println("Login button is enabled");
}else{
System.out.println("Login button is disabled");
}
It can also be used with input fields.
WebElement username = driver.findElement(By.id("username"));
if(username.isEnabled()){
username.sendKeys("admin");
}
This example enters data only when the username field is enabled.
WebElement password = driver.findElement(By.id("password"));
System.out.println("Password field enabled: " + password.isEnabled());
A checkbox can also be checked for its enabled state.
WebElement termsCheckbox = driver.findElement(By.id("terms"));
if(termsCheckbox.isEnabled()){
System.out.println("Terms checkbox can be interacted with");
}
WebElement maleRadio = driver.findElement(By.id("male"));
if(maleRadio.isEnabled()){
maleRadio.click();
}
A select control can also be checked before interacting with it.
WebElement country = driver.findElement(By.id("country"));
if(country.isEnabled()){
Select select = new Select(country);
select.selectByVisibleText("India");
}
HTML form controls can be disabled using the disabled attribute.
<button id="submitBtn" disabled>Submit</button>For such a button, Selenium can report:
WebElement submit = driver.findElement(By.id("submitBtn"));
System.out.println(submit.isEnabled());
The result is normally:
false<button id="submitBtn">Submit</button>WebElement submit = driver.findElement(By.id("submitBtn"));
System.out.println(submit.isEnabled());
For an enabled button, Selenium normally returns:
true<input type="text" id="username" disabled>WebElement username = driver.findElement(By.id("username"));
System.out.println(username.isEnabled());
The expected result is:
false<input type="text" id="username">WebElement username = driver.findElement(By.id("username"));
System.out.println(username.isEnabled());
The expected result is:
trueisEnabled() and isDisplayed() perform different checks. An element can be enabled but not currently displayed.
WebElement element = driver.findElement(By.id("myElement"));
System.out.println("Enabled: " + element.isEnabled());
System.out.println("Displayed: " + element.isDisplayed());
| Method | Purpose | Return Type |
|---|---|---|
| isEnabled() | Checks enabled state | boolean |
| isDisplayed() | Checks displayed state | boolean |
isEnabled() does not tell whether a checkbox, radio button, or option is selected.
WebElement checkbox = driver.findElement(By.id("subscribe"));
System.out.println("Enabled: " + checkbox.isEnabled());
System.out.println("Selected: " + checkbox.isSelected());
These are two different states.
| Method | Checks | Return | Typical Usage |
|---|---|---|---|
| isEnabled() | Enabled state | boolean | Buttons, inputs, controls |
| isDisplayed() | Displayed state | boolean | Visibility checks |
| isSelected() | Selection state | boolean | Checkbox, radio, option |
Sometimes a test needs to verify that an element is both visible and enabled.
WebElement loginButton = driver.findElement(By.id("loginBtn"));
if(loginButton.isDisplayed() && loginButton.isEnabled()){
System.out.println("Login button is visible and enabled");
}
WebElement submitButton = driver.findElement(By.id("submitBtn"));
if(submitButton.isEnabled()){
submitButton.click();
}else{
System.out.println("Submit button is disabled");
}
This can be useful when the application intentionally disables a control until some condition is satisfied.
isEnabled() checks the element's state at the moment the method is executed. It does not automatically wait for the element to become enabled.
boolean enabled = button.isEnabled();If the application enables the button two seconds later, the above statement does not wait two seconds and check again.
For dynamic applications, an explicit wait is usually more appropriate than repeatedly calling isEnabled() manually.
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement button = wait.until(
ExpectedConditions.elementToBeClickable(By.id("submitBtn"))
);
button.click();
elementToBeClickable() is commonly used when the test needs an element that is visible and enabled for clicking.
If the test specifically needs to wait for the enabled state, a custom condition can be used.
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
wait.until(driver -> driver.findElement(By.id("submitBtn")).isEnabled());
For highly dynamic pages, locating the element inside the wait condition can be safer because the DOM may be refreshed or replaced.
Consider a login page where the Login button is disabled until the required fields are completed.
WebElement username = driver.findElement(By.id("username"));
WebElement password = driver.findElement(By.id("password"));
WebElement loginButton = driver.findElement(By.id("loginBtn"));
username.sendKeys("admin");
password.sendKeys("admin123");
if(loginButton.isEnabled()){
loginButton.click();
}
A form may keep the Submit button disabled until all mandatory fields contain valid information.
WebElement submit = driver.findElement(By.id("submit"));
System.out.println("Before entering data: " + submit.isEnabled());
driver.findElement(By.id("name")).sendKeys("Rahul");
driver.findElement(By.id("email")).sendKeys("[email protected]");
System.out.println("After entering data: " + submit.isEnabled());
Some applications enable a Submit or Continue button only after the user accepts terms and conditions.
WebElement terms = driver.findElement(By.id("terms"));
WebElement continueButton = driver.findElement(By.id("continue"));
terms.click();
if(continueButton.isEnabled()){
continueButton.click();
}
In an e-commerce application, the Checkout button may become enabled only after a valid product or shipping information is available.
WebElement checkout = driver.findElement(By.id("checkout"));
if(checkout.isEnabled()){
checkout.click();
}else{
System.out.println("Checkout button is disabled");
}
WebElement paymentButton = driver.findElement(By.id("payNow"));
if(paymentButton.isEnabled()){
System.out.println("Payment button is ready for interaction");
}else{
System.out.println("Payment button is disabled");
}
isEnabled() can be used with elements located using XPath.
WebElement submit = driver.findElement(
By.xpath("//button[@type='submit']")
);
System.out.println(submit.isEnabled());
WebElement submit = driver.findElement(
By.cssSelector("button[type='submit']")
);
System.out.println(submit.isEnabled());
List<WebElement> buttons = driver.findElements(By.tagName("button"));
for(WebElement button : buttons){
System.out.println("Button enabled: " + button.isEnabled());
}
List<WebElement> inputs = driver.findElements(By.cssSelector("input"));
for(WebElement input : inputs){
System.out.println(
input.getAttribute("name") + " enabled: " + input.isEnabled()
);
}
In TestNG, isEnabled() can be combined with assertions.
WebElement loginButton = driver.findElement(By.id("loginBtn"));
Assert.assertTrue(loginButton.isEnabled());
WebElement submitButton = driver.findElement(By.id("submitBtn"));
Assert.assertFalse(submitButton.isEnabled());
WebElement submitButton = driver.findElement(By.id("submitBtn"));
Assert.assertTrue(submitButton.isEnabled());
submitButton.click();
It is possible to inspect the HTML using getAttribute("disabled"), but this is not the same as asking WebDriver whether the element is enabled.
WebElement button = driver.findElement(By.id("submitBtn"));
System.out.println("Enabled: " + button.isEnabled());
System.out.println("Disabled attribute: " + button.getAttribute("disabled"));
When the testing requirement is specifically to verify whether a form control is enabled, isEnabled() is generally the clearer semantic check.
<button id="submitBtn" disabled>Submit</button>WebElement button = driver.findElement(By.id("submitBtn"));
String disabled = button.getAttribute("disabled");
boolean enabled = button.isEnabled();
System.out.println("disabled attribute: " + disabled);
System.out.println("enabled: " + enabled);
HTML can disable groups of form controls through a disabled fieldset. In such cases, the child control may not itself contain a disabled attribute even though its effective enabled state is affected.
<fieldset disabled>
<input id="username">
<button id="submit">Submit</button>
</fieldset>
This is one reason a semantic enabled-state check is preferable when the test intent is to verify whether the control can be enabled for interaction.
readonly and disabled are different concepts.
<input id="username" readonly>
<input id="password" disabled>
A readonly text field can remain enabled according to WebDriver while preventing the user from editing its value. A disabled control is not enabled for normal interaction.
| State | Meaning |
|---|---|
| readonly | Value generally cannot be edited by the user. |
| disabled | Control is disabled for normal form interaction. |
Modern applications may use aria-disabled="true" to communicate an application's disabled state.
<button aria-disabled="true">Submit</button>ARIA state and native HTML disabled state are not identical. If an application uses ARIA-only state management, the automation test may need to verify the relevant application attribute or behavior separately.
An element can be enabled and still fail when Selenium tries to click it. For example, another element may cover it, the DOM may change, the element may become stale, or the application may have another interaction constraint.
WebElement button = driver.findElement(By.id("submit"));
if(button.isEnabled()){
button.click();
}
The condition confirms enabled state, but it does not guarantee that the subsequent click will succeed in every situation.
When the objective is specifically to click an element, Selenium's explicit wait condition elementToBeClickable() is often more suitable.
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement button = wait.until(
ExpectedConditions.elementToBeClickable(By.id("submit"))
);
button.click();
This condition is intended for an element that is visible and enabled for clicking.
If the locator cannot find the element, Selenium does not reach the isEnabled() call. The findElement() operation can throw NoSuchElementException.
WebElement button = driver.findElement(By.id("submit"));
boolean enabled = button.isEnabled();
The element must first be successfully located before its enabled state can be checked.
For elements that appear dynamically, explicit waits are generally preferable to immediately calling isEnabled().
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement button = wait.until(
ExpectedConditions.elementToBeClickable(By.id("submit"))
);
button.click();
Modern applications may rebuild elements through JavaScript or framework rendering. If a stored WebElement refers to an old DOM node, Selenium may throw StaleElementReferenceException.
WebElement button = driver.findElement(By.id("submit"));
driver.navigate().refresh();
boolean enabled = button.isEnabled();
In dynamic situations, locating the element again can be safer.
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
wait.until(driver -> driver.findElement(By.id("submit")).isEnabled());
In the Page Object Model, enabled-state checks can be encapsulated inside page classes.
public boolean isLoginButtonEnabled(){
return loginButton.isEnabled();
}
The test class can then use:
Assert.assertTrue(loginPage.isLoginButtonEnabled());public class LoginPage {
private WebDriver driver;
private By username = By.id("username");
private By password = By.id("password");
private By loginButton = By.id("loginBtn");
public LoginPage(WebDriver driver){
this.driver = driver;
}
public void enterUsername(String value){
driver.findElement(username).sendKeys(value);
}
public void enterPassword(String value){
driver.findElement(password).sendKeys(value);
}
public boolean isLoginButtonEnabled(){
return driver.findElement(loginButton).isEnabled();
}
public void clickLogin(){
driver.findElement(loginButton).click();
}
}
LoginPage loginPage = new LoginPage(driver);
loginPage.enterUsername("admin");
loginPage.enterPassword("admin123");
Assert.assertTrue(loginPage.isLoginButtonEnabled());
loginPage.clickLogin();
Open Login Page
↓
Enter Username
↓
Enter Password
↓
Application Validates Credentials
↓
Login Button Becomes Enabled
↓
Check isEnabled()
↓
Click Login Button
Open Registration Form
↓
Enter Required Details
↓
Accept Terms
↓
Client-Side Validation
↓
Submit Button Enabled
↓
Verify isEnabled()
↓
Submit Form
Add Product to Cart
↓
Open Cart
↓
Enter Shipping Details
↓
Select Delivery Method
↓
Application Validates Information
↓
Checkout Button Enabled
↓
Verify isEnabled()
↓
Proceed to Checkout
WebElement name = driver.findElement(By.id("name"));
WebElement email = driver.findElement(By.id("email"));
WebElement phone = driver.findElement(By.id("phone"));
WebElement submit = driver.findElement(By.id("submit"));
System.out.println("Name enabled: " + name.isEnabled());
System.out.println("Email enabled: " + email.isEnabled());
System.out.println("Phone enabled: " + phone.isEnabled());
System.out.println("Submit enabled: " + submit.isEnabled());
WebElement nextButton = driver.findElement(By.id("next"));
if(nextButton.isEnabled()){
nextButton.click();
}else{
System.out.println("Next button is not enabled yet");
}
WebElement username = driver.findElement(By.id("username"));
if(username.isEnabled()){
username.clear();
username.sendKeys("admin");
}
WebElement country = driver.findElement(By.id("country"));
if(country.isEnabled()){
Select select = new Select(country);
select.selectByVisibleText("India");
}
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(15));
wait.until(driver -> {
WebElement submit = driver.findElement(By.id("submit"));
return submit.isDisplayed() && submit.isEnabled();
});
For a fully dynamic element that can be replaced in the DOM, locating it again inside the condition is safer than relying on an old WebElement reference.
WebElement button = driver.findElement(By.id("submit"));
boolean ready = button.isDisplayed() && button.isEnabled();
System.out.println("Button ready: " + ready);
When an element may not exist on a page, findElements() can be useful because it returns an empty list instead of throwing NoSuchElementException.
List<WebElement> buttons = driver.findElements(By.id("submit"));
if(!buttons.isEmpty()){
System.out.println("Enabled: " + buttons.get(0).isEnabled());
}else{
System.out.println("Submit button is not present");
}
WebElement submit = driver.findElement(By.id("submit"));
Assert.assertFalse(submit.isEnabled());
WebElement submit = driver.findElement(By.id("submit"));
Assert.assertTrue(submit.isEnabled());
Suppose a registration form contains Name, Email, Password, Confirm Password, and Submit controls. The Submit button is disabled until all required fields are valid.
WebElement submit = driver.findElement(By.id("submit"));
Assert.assertFalse(submit.isEnabled());
driver.findElement(By.id("name")).sendKeys("Amit");
driver.findElement(By.id("email")).sendKeys("[email protected]");
driver.findElement(By.id("password")).sendKeys("Password123");
driver.findElement(By.id("confirmPassword")).sendKeys("Password123");
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
wait.until(driver -> driver.findElement(By.id("submit")).isEnabled());
Assert.assertTrue(driver.findElement(By.id("submit")).isEnabled());
A practical Selenium project can validate an e-commerce checkout process.
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement checkout = wait.until(
ExpectedConditions.visibilityOfElementLocated(By.id("checkout"))
);
boolean enabled = checkout.isEnabled();
if(enabled){
checkout.click();
System.out.println("Checkout button clicked successfully");
}else{
System.out.println("Checkout button is disabled");
}
A common mistake is assuming that an enabled element must also be visible.
WebElement element = driver.findElement(By.id("submit"));
System.out.println(element.isEnabled());
System.out.println(element.isDisplayed());
These methods answer different questions and should be used according to the test requirement.
An enabled element may still have another element covering it or may be affected by a dynamic page change. Therefore, enabled state alone should not be treated as a guarantee that a click will succeed.
Avoid using fixed delays as the primary solution for waiting for an element to become enabled.
Thread.sleep(5000);
button.click();
Instead, use an explicit wait based on the actual application condition.
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement button = wait.until(
ExpectedConditions.elementToBeClickable(By.id("submit"))
);
button.click();
Using only getAttribute("disabled") may not express the actual test requirement. If the requirement is "verify whether the control is enabled," use isEnabled().
isEnabled() belongs to WebElement, so Selenium must first locate the element.
WebElement button = driver.findElement(By.id("submit"));
boolean enabled = button.isEnabled();
| Method | Question Answered | Example |
|---|---|---|
| isDisplayed() | Is the element displayed? | Verify error message visibility |
| isEnabled() | Is the element enabled? | Verify Submit button state |
| isSelected() | Is the element selected? | Verify checkbox state |
| getText() | What visible text does it contain? | Read heading text |
| getAttribute() | What attribute/property-related value is exposed? | Read class or value |
| getSize() | What is the element's size? | Read width and height |
| getLocation() | Where is the element located? | Read x and y coordinates |
Answer: isEnabled() is a Selenium WebElement method used to determine whether an element is enabled. It returns a boolean value. It is commonly used with buttons, input fields, checkboxes, radio buttons, and other form controls.
Answer: It returns a boolean value. It returns true when the element is enabled and false when the element is disabled.
Answer: isEnabled() checks whether the element is enabled, while isDisplayed() checks whether the element is displayed according to WebDriver's displayedness semantics.
Answer: No. isEnabled() only checks the enabled state. It does not perform any interaction. The click() method must be used to click an element.
Answer: No. isEnabled() performs an immediate state check. For dynamic applications, use WebDriverWait and an appropriate expected condition or custom condition.
Answer: Yes. An enabled element may still be affected by overlays, layout changes, stale references, or other application conditions. Therefore, isEnabled() should not be treated as a complete guarantee of click success.
Answer: A disabled control is not enabled for normal interaction, while a readonly field can generally remain enabled but does not allow the user to edit its value in the normal way.
Answer: For a click operation, use an explicit wait with ExpectedConditions.elementToBeClickable(). When the requirement is specifically the enabled state, a custom wait condition can check isEnabled().
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
wait.until(driver -> driver.findElement(By.id("submit")).isEnabled());
WebElement button = driver.findElement(By.id("submit"));
Assert.assertFalse(button.isEnabled());
WebElement button = driver.findElement(By.id("submit"));
Assert.assertTrue(button.isEnabled());
Answer: Yes. Selenium first locates the element using XPath and then calls isEnabled().
WebElement button = driver.findElement(
By.xpath("//button[@type='submit']")
);
boolean enabled = button.isEnabled();
Answer: Yes.
WebElement button = driver.findElement(
By.cssSelector("button[type='submit']")
);
boolean enabled = button.isEnabled();
Answer: The WebElement interface provides the isEnabled() method in Selenium WebDriver.
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
import java.time.Duration;
public class IsEnabledExample {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
driver.get("https://example.com");
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement submit = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("submit")
)
);
if(submit.isEnabled()){
System.out.println("Submit button is enabled");
}else{
System.out.println("Submit button is disabled");
}
driver.quit();
}
}
Start Test
↓
Open Web Application
↓
Locate Web Element
↓
Check isDisplayed()
↓
Check isEnabled()
↓
If Enabled
↓
Perform Interaction
↓
Verify Result
↓
Continue Test
↓
End Test
isEnabled() is an important Selenium WebElement method for validating whether an element is enabled for interaction. It returns a boolean value and is especially useful for testing dynamic buttons, input fields, checkboxes, radio buttons, select controls, and form submission workflows.
For reliable automation, remember that isEnabled() checks enabled state only. It does not replace isDisplayed(), isSelected(), explicit waits, or application-specific validation. When a control changes state dynamically, use an appropriate explicit wait and re-locate elements when necessary to handle DOM updates safely.
For structured Selenium learning covering WebDriver, WebElements, locators, TestNG, automation frameworks, Page Object Model, data-driven testing, and real-time projects, visit JustAcademy Selenium Training.
For a practical introduction or course demonstration, visit Register for Selenium Course Demo.
